<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:msxsl="urn:schemas-microsoft-com:xslt" xmlns:nyext="urn:noury-extensions">
  <xsl:output method="text" encoding="UTF-8"/>
  
  <xsl:param name="package"/>
  <xsl:param name="outdir"/>
  <xsl:param name="name"/>
  <xsl:param name="domainName"/>
  <xsl:variable name="domain" select="/manifest/types/domain[@name=$domainName]"/>
  
  <xsl:variable name="pkdomainName">
    <xsl:apply-templates select="$domain" mode="get-pk-name"/>
  </xsl:variable>
  
  <xsl:variable name="pkdomain" select="/manifest/types/domain[@name=$pkdomainName]"/>
  <!--  <xsl:variable name="oracle" select="/manifest/configuration/sql[@provider='Oracle']" /> -->
  <xsl:variable name="oracle"/>
  <xsl:include href="functions.xslt"/>

  <xsl:template name="get-mapper-name">
    <xsl:value-of select="$domainName"/>
    <xsl:text>Mapper</xsl:text>
  </xsl:template>

  <xsl:template name="get-imapper-name">
    <xsl:text>I</xsl:text>
    <xsl:call-template name="get-mapper-name"/>
  </xsl:template>

  <xsl:template name="get-visibility">
    <xsl:choose>
      <xsl:when test="not($domain/@visibility)">
        <xsl:text>public</xsl:text>
      </xsl:when>
      <xsl:otherwise>
        <!--        <xsl:text>public</xsl:text> -->
        <xsl:value-of select="$domain/@visibility"/>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>

  <xsl:template match="field" mode="get-dbtype">
    <xsl:variable name="columnName" select="@column"/>
    <xsl:variable name="dbtype" select="$domain/table/column[@name=$columnName]/@type"/>
    <xsl:choose>
      <xsl:when test="$dbtype='BOOLEAN'">
        <xsl:text>Boolean</xsl:text>
      </xsl:when>
      <xsl:when test="$dbtype='TINYINT'">
        <xsl:text>Byte</xsl:text>
      </xsl:when>
      <xsl:when test="$dbtype='DATE'">
        <xsl:text>Date</xsl:text>
      </xsl:when>
      <xsl:when test="$dbtype='TIMESTAMP'">
        <xsl:text>DateTime</xsl:text>
      </xsl:when>
      <xsl:when test="$dbtype='DECIMAL'">
        <xsl:text>Decimal</xsl:text>
      </xsl:when>
      <xsl:when test="$dbtype='DOUBLE' or $dbtype='FLOAT'">
        <xsl:text>Double</xsl:text>
      </xsl:when>
      <xsl:when test="$dbtype='SMALLINT'">
        <xsl:text>Int16</xsl:text>
      </xsl:when>
      <xsl:when test="$dbtype='INTEGER'">
        <xsl:text>Int32</xsl:text>
      </xsl:when>
      <xsl:when test="$dbtype='BIGINT'">
        <xsl:text>Int64</xsl:text>
      </xsl:when>
      <xsl:when test="$dbtype='REAL'">
        <xsl:text>Single</xsl:text>
      </xsl:when>
      <xsl:when test="$dbtype='VARCHAR' or $dbtype='CHAR' or $dbtype='LONGVARCHAR'">
        <xsl:text>String</xsl:text>
      </xsl:when>
      <xsl:otherwise>
        <xsl:text>Object</xsl:text>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>

  <xsl:template match="field" mode="get-getter">
    <xsl:variable name="columnName" select="@column"/>
    <xsl:variable name="dbtype" select="$domain/table/column[@name=$columnName]/@type"/>
    <xsl:choose>
      <xsl:when test="$dbtype='BOOLEAN'">
        <xsl:text>GetBoolean</xsl:text>
      </xsl:when>
      <xsl:when test="$dbtype='TINYINT'">
        <xsl:text>GetByte</xsl:text>
      </xsl:when>
      <xsl:when test="$dbtype='DATE'">
        <xsl:text>GetDateTime</xsl:text>
      </xsl:when>
      <xsl:when test="$dbtype='TIMESTAMP'">
        <xsl:text>DateTime</xsl:text>
      </xsl:when>
      <xsl:when test="$dbtype='DECIMAL'">
        <xsl:text>GetDecimal</xsl:text>
      </xsl:when>
      <xsl:when test="$dbtype='DOUBLE' or $dbtype='FLOAT'">
        <xsl:choose>
          <xsl:when test="$oracle">
            <xsl:text>GetDecimal</xsl:text>
          </xsl:when>
          <xsl:otherwise>
            <xsl:text>GetDouble</xsl:text>
          </xsl:otherwise>
        </xsl:choose>
      </xsl:when>
      <xsl:when test="$dbtype='SMALLINT'">
        <xsl:choose>
          <xsl:when test="$oracle">
            <xsl:text>GetDecimal</xsl:text>
          </xsl:when>
          <xsl:otherwise>
            <xsl:text>GetInt16</xsl:text>
          </xsl:otherwise>
        </xsl:choose>
      </xsl:when>
      <xsl:when test="$dbtype='INTEGER'">
        <xsl:choose>
          <xsl:when test="$oracle">
            <xsl:text>GetDecimal</xsl:text>
          </xsl:when>
          <xsl:otherwise>
            <xsl:text>GetInt32</xsl:text>
          </xsl:otherwise>
        </xsl:choose>
      </xsl:when>
      <xsl:when test="$dbtype='BIGINT'">
        <xsl:choose>
          <xsl:when test="$oracle">
            <xsl:text>GetDecimal</xsl:text>
          </xsl:when>
          <xsl:otherwise>
            <xsl:text>GetInt64</xsl:text>
          </xsl:otherwise>
        </xsl:choose>
      </xsl:when>
      <xsl:when test="$dbtype='REAL'">
        <xsl:choose>
          <xsl:when test="$oracle">
            <xsl:text>GetDecimal</xsl:text>
          </xsl:when>
          <xsl:otherwise>
            <xsl:text>GetFloat</xsl:text>
          </xsl:otherwise>
        </xsl:choose>
      </xsl:when>
      <xsl:when test="$dbtype='VARCHAR' or $dbtype='CHAR' or @type='LONGVARCHAR'">
        <xsl:text>GetString</xsl:text>
      </xsl:when>
      <xsl:otherwise>
        <xsl:text>GetValue</xsl:text>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>

  <xsl:template match="field" mode="parameter-args">
    <xsl:param name="pos"/>
    <xsl:param name="val"/>
    <xsl:variable name="c" select="@column"/>
    <xsl:variable name="pec" select="../../table/column[@name=$c and @type='CHAR']"/>
    <xsl:variable name="pev" select="../../table/column[@name=$c and @type='VARCHAR']"/>
    <xsl:text>
                command,
                parameterBuilder.GetName("</xsl:text>
    <xsl:value-of select="@column"/>
    <xsl:text>", </xsl:text>
    <xsl:value-of select="$pos"/>
    <xsl:text>),
                DbType.</xsl:text>
    <xsl:apply-templates select="." mode="get-dbtype"/>
    <xsl:text>,</xsl:text>
<!--    <xsl:if test="$pec">
      <xsl:text>
                </xsl:text>
      <xsl:value-of select="$pec/@size"/>
      <xsl:text>,</xsl:text>
    </xsl:if> -->
    <xsl:if test="$pec or $pev">
      <xsl:text>
                </xsl:text>
      <xsl:apply-templates select="." mode="get-length"/>
      <xsl:text>,</xsl:text>
    </xsl:if>
    <xsl:text>
                ParameterDirection.Input,</xsl:text>
    <xsl:if test="$pec or $pev">
      <xsl:text>
                false,
                0,
                0,</xsl:text>
    </xsl:if>
    <xsl:text>
                string.Empty,
                DataRowVersion.Default,
                </xsl:text>
    <xsl:choose>
      <xsl:when test="$val">
        <xsl:value-of select="$val" />
      </xsl:when>
      <xsl:otherwise>
        <xsl:apply-templates select="." mode="get-value"/>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>

  <xsl:template match="field" mode="get-value">
    <xsl:param name="dtname" select="'data'"/>
    <xsl:variable name="code">
      <xsl:variable name="c" select="@column"/>
      <xsl:variable name="column" select="../../table/column[@name=$c]"/>
      <xsl:variable name="b" select="(not(@nullable) or @nullable='false') and (not($column/@required) or $column/@required='false')"/>
      <xsl:if test="$b">
        <xsl:text>(object)</xsl:text>
      </xsl:if>
      <xsl:variable name="type" select="@type"/>
      <xsl:variable name="pec" select="/manifest/types/enum[@name=$type]"/>
      <xsl:choose>
        <xsl:when test="$pec">
          <xsl:text>new PersistentEnumConverter(typeof(</xsl:text>
          <xsl:value-of select="$type"/>
          <xsl:text>)).ConvertToInvariantString(</xsl:text>
        </xsl:when>
      </xsl:choose>
      <xsl:value-of select="$dtname"/>
      <xsl:text>.</xsl:text>
      <xsl:value-of select="@name"/>
      <xsl:if test="$b">
        <xsl:text> ?? (object)DBNull.Value</xsl:text>
      </xsl:if>
      <xsl:choose>
        <xsl:when test="$pec">
          <xsl:text>)</xsl:text>
        </xsl:when>
      </xsl:choose>
    </xsl:variable>
    <xsl:choose>
      <xsl:when test="from[@language='C#']">
        <xsl:value-of select="nyext:stringFormat(from[@language='C#'], $code)"/>
      </xsl:when>
      <xsl:otherwise>
        <xsl:value-of select="$code"/>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>

  <xsl:template match="field" mode="get-length">
    <xsl:param name="dtname" select="'data'"/>
      <xsl:variable name="c" select="@column"/>
      <xsl:variable name="column" select="../../table/column[@name=$c]"/>
      <xsl:if test="$column/@size">
        <xsl:value-of select="$column/@size"/>
      </xsl:if>
  </xsl:template>

  <xsl:template match="field" mode="set-value">
    <xsl:param name="dtname" select="'data'"/>
    <xsl:param name="pos"/>
    <xsl:value-of select="$dtname"/>
    <xsl:text>.</xsl:text>
    <xsl:value-of select="@name"/>
    <xsl:text>=</xsl:text>
    <xsl:variable name="code">
      <xsl:variable name="type" select="@type"/>
      <xsl:variable name="pec" select="/manifest/types/enum[@name=$type]"/>
      <xsl:choose>
        <xsl:when test="$pec">
          <xsl:text>(</xsl:text>
          <xsl:value-of select="$type"/>
          <xsl:text>)new PersistentEnumConverter(typeof(</xsl:text>
          <xsl:value-of select="$type"/>
          <xsl:text>)).ConvertFromInvariantString(</xsl:text>
        </xsl:when>
        <xsl:when test="$oracle and not(to[@language='C#'])">
          <xsl:text>(</xsl:text>
          <xsl:value-of select="$type"/>
          <xsl:text>)</xsl:text>
        </xsl:when>
      </xsl:choose>
      <xsl:text>record.</xsl:text>
      <xsl:apply-templates select="." mode="get-getter"/>
      <xsl:text>(ord)</xsl:text>
      <xsl:if test="$pec">
        <xsl:text>)</xsl:text>
      </xsl:if>
    </xsl:variable>
    <xsl:choose>
      <xsl:when test="to[@language='C#']">
        <xsl:value-of select="nyext:stringFormat(to[@language='C#'], $code)"/>
      </xsl:when>
      <xsl:otherwise>
        <xsl:value-of select="$code"/>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>

  <xsl:template match="*" mode="get-type">
    <xsl:value-of select="@type"/>
    <xsl:if test="@nullable='true'">
      <xsl:text>?</xsl:text>
    </xsl:if>
  </xsl:template>
  <!--  
  <xsl:template match="field" mode="get-value">
    <xsl:variable name="c" select="@column" />
    <xsl:variable name="column" select="../../table/column[@name=$c]" />
    <xsl:value-of select="@name" />
    <xsl:if test="(not(@nullable) or @nullable='false') and (not($column/@required) or $column/@required='false')">
      <xsl:text> ?? (object)DBNull.Value</xsl:text>
    </xsl:if>
  </xsl:template>
-->
  <xsl:template name="get-pk-type">
    <xsl:choose>
      <xsl:when test="count($pkdomain/pk/field) &gt; 1">
        <xsl:text>PrimaryKey.Key</xsl:text>
      </xsl:when>
      <xsl:otherwise>
        <xsl:apply-templates select="$pkdomain/data/field[@name=$pkdomain/pk/field/@name]" mode="get-type"/>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>

  <xsl:template match="domain" mode="get-pk-domain">
    <xsl:choose>
      <xsl:when test="@extends">
        <xsl:variable name="extends" select="@extends"/>
        <xsl:apply-templates select="/manifest/types/domain[@name=$extends]" mode="get-pk-domain"/>
      </xsl:when>
      <xsl:when test="pk/@ref">
        <xsl:variable name="ref" select="pk/@ref"/>
        <xsl:apply-templates select="/manifest/types/domain[@name=$ref]" mode="get-pk-domain"/>
      </xsl:when>
      <xsl:otherwise>
        <xsl:copy-of select="."/>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>

  <xsl:template match="domain" mode="get-pk-name">
    <xsl:choose>
      <xsl:when test="@extends">
        <xsl:variable name="extends" select="@extends"/>
        <xsl:apply-templates select="/manifest/types/domain[@name=$extends]" mode="get-pk-name"/>
      </xsl:when>
      <xsl:when test="pk/@ref">
        <xsl:variable name="ref" select="pk/@ref"/>
        <xsl:apply-templates select="/manifest/types/domain[@name=$ref]" mode="get-pk-name"/>
      </xsl:when>
      <xsl:otherwise>
        <xsl:value-of select="@name"/>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>

  <xsl:template match="domain" mode="get-data-name">
    <xsl:choose>
      <xsl:when test="@extends">
        <xsl:variable name="extends" select="@extends"/>
        <xsl:apply-templates select="/manifest/types/domain[@name=$extends]" mode="get-data-name"/>
      </xsl:when>
      <xsl:otherwise>
        <xsl:value-of select="@name"/>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>

  <xsl:template name="get-element-name">
    <xsl:param name="element"/>
    <xsl:param name="prefix"/>
    <xsl:param name="suffix"/>
    <xsl:choose>
      <xsl:when test="$element/@shortName">
        <xsl:value-of select="concat($prefix, $element/@shortName, $suffix)"/>
      </xsl:when>
      <xsl:otherwise>
        <xsl:value-of select="concat($prefix, $element/@name, $suffix)"/>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>

  <xsl:template name="generate-user-file">
    <xsl:text>// $Id$
/*! \file
 * \brief Definition of </xsl:text>
    <xsl:value-of select="$package"/>
    <xsl:text>.</xsl:text>
    <xsl:call-template name="get-mapper-name"/>
    <xsl:text>.
 *
 * \author $Author$
 * \date $Date$
 * \version $Revision$
 */

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using Microsoft.Practices.EnterpriseLibrary.Data;
using Salamanca.DataAccess;
using Salamanca.DataAccess.Collections;
using Salamanca.DataAccess.EnterpriseLibrary.Data;

namespace </xsl:text>
    <xsl:value-of select="$package"/>
    <xsl:text>
{



    ///////////////////////////////////////////////////////////////////////////
    ///
    /// &lt;summary /&gt;
    ///
    ///////////////////////////////////////////////////////////////////////////

    </xsl:text>
    <xsl:call-template name="get-visibility"/>
    <xsl:text> partial class </xsl:text>
    <xsl:call-template name="get-mapper-name"/>
    <xsl:text>:
        DataMapper&lt;</xsl:text>
    <xsl:value-of select="$domainName"/>
    <xsl:text>, </xsl:text>
    <xsl:apply-templates select="$domain" mode="get-pk-name"/>
    <xsl:text>.PrimaryKey, </xsl:text>
    <xsl:apply-templates select="$domain" mode="get-data-name"/>
    <xsl:text>.DataTransfer&gt;,
        </xsl:text>
    <xsl:call-template name="get-imapper-name"/>
    <xsl:text>
    {

        /// &lt;summary /&gt;
        public </xsl:text>
    <xsl:call-template name="get-mapper-name"/>
    <xsl:text>(Database database, ICacheManager cacheManager):
            base(database, DomainEntityCreator.CreateDefault&lt;</xsl:text>
    <xsl:value-of select="$domainName"/>
    <xsl:text>&gt;(), cacheManager)
        {
            _ParameterBuilder=new Salamanca.DataAccess.Data.ParameterBuilder(database.CreateConnection());
        }

        /// &lt;summary /&gt;
        public DomainEntityKeyedCollection&lt;</xsl:text>
    <xsl:value-of select="$domainName"/>
    <xsl:text>&gt; FindAll(DataMapperCollection dataMappers)
        {
            return _FindAll(dataMappers);
        }

        /// &lt;summary /&gt;
        protected override IList&lt;DbCommand&gt; CreateSelectCommands(</xsl:text>
    <xsl:apply-templates select="$domain" mode="get-pk-name"/>
    <xsl:text>.PrimaryKey key)
        {
            return CreateSelectCommands(Database, ParameterBuilder, key);
        }

        /// &lt;summary /&gt;
        protected override IList&lt;DbCommand&gt; CreateDeleteCommands(</xsl:text>
    <xsl:apply-templates select="$domain" mode="get-data-name"/>
    <xsl:text>.DataTransfer data)
        {
            return CreateDeleteCommands(Database, ParameterBuilder, (</xsl:text>
    <xsl:value-of select="$domainName"/>
    <xsl:text>.DataTransfer)data);
        }

        /// &lt;summary /&gt;
        protected override IList&lt;DbCommand&gt; CreateInsertCommands(</xsl:text>
    <xsl:apply-templates select="$domain" mode="get-data-name"/>
    <xsl:text>.DataTransfer data)
        {
            return CreateInsertCommands(Database, ParameterBuilder, (</xsl:text>
    <xsl:value-of select="$domainName"/>
    <xsl:text>.DataTransfer)data);
        }

        /// &lt;summary /&gt;
        protected override IList&lt;DbCommand&gt; CreateUpdateCommands(</xsl:text>
    <xsl:apply-templates select="$domain" mode="get-data-name"/>
    <xsl:text>.DataTransfer data)
        {
            return CreateUpdateCommands(Database, ParameterBuilder, (</xsl:text>
    <xsl:value-of select="$domainName"/>
    <xsl:text>.DataTransfer)data);
        }

        /// &lt;summary /&gt;
        protected override </xsl:text>
    <xsl:apply-templates select="$domain" mode="get-data-name"/>
    <xsl:text>.DataTransfer GetDataTransferObject(IList&lt;IDataRecord&gt; records)
        {
          return _GetDataTransferObject(records);
        }</xsl:text>
    <xsl:if test="not($domain/@extends) and not($domain/pk/@ref) and count($pkdomain/pk/field)=1">
      <xsl:text>

        /// &lt;summary /&gt;
        protected override void OnInserted(</xsl:text>
      <xsl:value-of select="$domainName"/>
      <xsl:text> domainModel, IList&lt;DbCommand&gt; commands)
        {
            _OnInserted(domainModel, commands);

            base.OnInserted(domainModel, commands);
        }</xsl:text>
    </xsl:if>
    <xsl:text>

        /// &lt;summary /&gt;
        internal static IList&lt;DbCommand&gt; CreateSelectCommands(Database database, Salamanca.DataAccess.Data.ParameterBuilder parameterBuilder, </xsl:text>
    <xsl:apply-templates select="$domain" mode="get-pk-name"/>
    <xsl:text>.PrimaryKey key)
        {
            return new DbCommand[] { _CreateSelectCommand(database, parameterBuilder, key) };
        }

        /// &lt;summary /&gt;
        internal static IList&lt;DbCommand&gt; CreateDeleteCommands(Database database, Salamanca.DataAccess.Data.ParameterBuilder parameterBuilder, </xsl:text>
    <xsl:apply-templates select="$domain" mode="get-data-name"/>
    <xsl:text>.DataTransfer data)
        {
            return new DbCommand[] { _CreateDeleteCommand(database, parameterBuilder, (</xsl:text>
    <xsl:value-of select="$domainName"/>
    <xsl:text>.DataTransfer)data) };
        }

        /// &lt;summary /&gt;
        internal static IList&lt;DbCommand&gt; CreateInsertCommands(Database database, Salamanca.DataAccess.Data.ParameterBuilder parameterBuilder, </xsl:text>
    <xsl:apply-templates select="$domain" mode="get-data-name"/>
    <xsl:text>.DataTransfer data)
        {
            return new DbCommand[] { _CreateInsertCommand(database, parameterBuilder, (</xsl:text>
    <xsl:value-of select="$domainName"/>
    <xsl:text>.DataTransfer)data) };
        }

        /// &lt;summary /&gt;
        internal static IList&lt;DbCommand&gt; CreateUpdateCommands(Database database, Salamanca.DataAccess.Data.ParameterBuilder parameterBuilder, </xsl:text>
    <xsl:apply-templates select="$domain" mode="get-data-name"/>
    <xsl:text>.DataTransfer data)
        {
            return new DbCommand[] { _CreateUpdateCommand(database, parameterBuilder, (</xsl:text>
    <xsl:value-of select="$domainName"/>
    <xsl:text>.DataTransfer)data) };
        }

    }
}
</xsl:text>
  </xsl:template>
  <xsl:template name="generate-model-file">
    <xsl:variable name="src">
      <xsl:text>// $Id$
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Globalization;
using Microsoft.Practices.EnterpriseLibrary.Data;
using Salamanca.DataAccess;
using Salamanca.DataAccess.Collections;
using Salamanca.DataAccess.EnterpriseLibrary.Data;

namespace </xsl:text>
      <xsl:value-of select="$package"/>
      <xsl:text>
{

    /// &lt;summary /&gt;
    partial class </xsl:text>
      <xsl:call-template name="get-mapper-name"/>
      <xsl:text>
    {

        /// &lt;summary /&gt;
        static </xsl:text>
      <xsl:call-template name="get-mapper-name"/>
      <xsl:text>()
        {
            Resources.Sql.Culture=CultureInfo.InvariantCulture;
        }

        /// &lt;summary /&gt;
        private DomainEntityKeyedCollection&lt;</xsl:text>
      <xsl:value-of select="$domainName"/>
      <xsl:text>&gt; _FindAll(DataMapperCollection dataMappers)
        {
            DbCommand[] commands=new DbCommand[1];

            commands[0]=Database.GetSqlStringCommand(Resources.Sql.</xsl:text>
      <xsl:value-of select="$domainName"/>
      <xsl:text>SelectAll);

            return Load(commands, dataMappers);
        }

        private </xsl:text>
      <xsl:value-of select="$domainName"/>
      <xsl:text>.DataTransfer _GetDataTransferObject(IList&lt;IDataRecord&gt; records)
        {
            </xsl:text>
      <xsl:value-of select="$domainName"/>
      <xsl:text>.DataTransfer data=new </xsl:text>
      <xsl:value-of select="$domainName"/>
      <xsl:text>.DataTransfer();

            return FillData(data, records[0]);
        }</xsl:text>
      <xsl:if test="not($domain/@extends) and not($domain/pk/@ref) and count($pkdomain/pk/field)=1">
        <xsl:text>

        /// &lt;summary /&gt;
        private void _OnInserted(</xsl:text>
        <xsl:value-of select="$domainName"/>
        <xsl:text> domainModel, IList&lt;DbCommand&gt; commands)
        {
            DbCommand c=Database.GetSqlStringCommand(
                Resources.Sql.</xsl:text>
        <xsl:value-of select="$domainName"/>
        <xsl:text>SelectId
            );
            c.Transaction=commands[0].Transaction;

            domainModel.SetId(Convert.To</xsl:text>
        <xsl:apply-templates select="$pkdomain/data/field[$pkdomain/pk/field/@name=@name]" mode="get-dbtype"/>
        <xsl:text>(Database.ExecuteScalar(c)));
        }</xsl:text>
      </xsl:if>
      <xsl:text>

        /// &lt;summary /&gt;
        internal static </xsl:text>
      <xsl:value-of select="$domainName"/>
      <xsl:text>.DataTransfer FillData(</xsl:text>
      <xsl:value-of select="$domainName"/>
      <xsl:text>.DataTransfer data, IDataRecord record)
        {</xsl:text>
      <xsl:if test="$domain/@extends">
        <xsl:text>
            </xsl:text>
        <xsl:value-of select="$domain/@extends"/>
        <xsl:text>Mapper.FillData(data, record);
</xsl:text>
      </xsl:if>
      <xsl:for-each select="$domain/data/field">
        <xsl:text>
            </xsl:text>
        <xsl:if test="position()=1">
          <xsl:text>int </xsl:text>
        </xsl:if>
        <xsl:text>ord=record.GetOrdinal("</xsl:text>
        <xsl:value-of select="@column"/>
        <xsl:text>");
            if (!record.IsDBNull(ord))
                </xsl:text>
        <xsl:apply-templates select="." mode="set-value">
          <xsl:with-param name="pos" select="position()-1"/>
        </xsl:apply-templates>
        <xsl:text>;
</xsl:text>
      </xsl:for-each>
      <xsl:text>
            return data;
        }

        /// &lt;summary /&gt;
        private static DbCommand _CreateSelectCommand(Database database, Salamanca.DataAccess.Data.ParameterBuilder parameterBuilder, </xsl:text>
      <xsl:apply-templates select="$domain" mode="get-pk-name"/>
      <xsl:text>.PrimaryKey key)
        {
            DbCommand command=database.GetSqlStringCommand(
                string.Format(
                    CultureInfo.InvariantCulture,
                    Resources.Sql.</xsl:text>
      <xsl:value-of select="$domainName"/>
      <xsl:text>Select,</xsl:text>
      <xsl:for-each select="$pkdomain/data/field[@name=$pkdomain/pk/field/@name]">
        <xsl:text>
                    parameterBuilder.GetMarker("</xsl:text>
        <xsl:value-of select="@column"/>
        <xsl:text>", </xsl:text>
        <xsl:value-of select="position()"/>
        <xsl:text>)</xsl:text>
        <xsl:if test="position()!=last()">
          <xsl:text>,</xsl:text>
        </xsl:if>
      </xsl:for-each>
      <xsl:text>
                )
            );
</xsl:text>
      <xsl:for-each select="$pkdomain/data/field[@name=$pkdomain/pk/field/@name]">
        <xsl:text>
            database.AddParameter(</xsl:text>
        <xsl:apply-templates select="." mode="parameter-args">
          <xsl:with-param name="pos" select="position()" />
          <xsl:with-param name="val" select="'key.Value'" />
        </xsl:apply-templates>
        <xsl:text>
            );
</xsl:text>
      </xsl:for-each>
      <xsl:text>
            return command;
        }

        /// &lt;summary /&gt;
        private static DbCommand _CreateDeleteCommand(Database database, Salamanca.DataAccess.Data.ParameterBuilder parameterBuilder, </xsl:text>
      <xsl:value-of select="$domainName"/>
      <xsl:text>.DataTransfer data)
        {
            DbCommand command=database.GetSqlStringCommand(
                string.Format(
                    CultureInfo.InvariantCulture,
                    Resources.Sql.</xsl:text>
      <xsl:value-of select="$domainName"/>
      <xsl:text>Delete,</xsl:text>
      <xsl:for-each select="$pkdomain/data/field[@name=$pkdomain/pk/field/@name]">
        <xsl:text>
                    parameterBuilder.GetMarker("</xsl:text>
        <xsl:value-of select="@column"/>
        <xsl:text>", </xsl:text>
        <xsl:value-of select="position()"/>
        <xsl:text>)</xsl:text>
        <xsl:if test="position()!=last()">
          <xsl:text>,</xsl:text>
        </xsl:if>
      </xsl:for-each>
      <xsl:text>
                )
            );
</xsl:text>
      <xsl:for-each select="$pkdomain/data/field[@name=$pkdomain/pk/field/@name]">
        <xsl:text>
            database.AddParameter(</xsl:text>
        <xsl:apply-templates select="." mode="parameter-args">
          <xsl:with-param name="pos" select="position()"/>
        </xsl:apply-templates>
        <xsl:text>
            );
</xsl:text>
      </xsl:for-each>
      <xsl:text>
            return command;
        }

        /// &lt;summary /&gt;
        private static DbCommand _CreateInsertCommand(Database database, Salamanca.DataAccess.Data.ParameterBuilder parameterBuilder, </xsl:text>
      <xsl:value-of select="$domainName"/>
      <xsl:text>.DataTransfer data)
        {
            DbCommand command=database.GetSqlStringCommand(
                string.Format(
                    CultureInfo.InvariantCulture,
                    Resources.Sql.</xsl:text>
      <xsl:value-of select="$domainName"/>
      <xsl:text>Insert,</xsl:text>
      <xsl:for-each select="$domain/data/field[@name!=$pkdomain/pk/field/@name]">
        <xsl:text>
                    parameterBuilder.GetMarker("</xsl:text>
        <xsl:value-of select="@column"/>
        <xsl:text>", </xsl:text>
        <xsl:value-of select="position()"/>
        <xsl:text>)</xsl:text>
        <xsl:if test="position()!=last()">
          <xsl:text>,</xsl:text>
        </xsl:if>
      </xsl:for-each>
      <xsl:text>
                )
            );
</xsl:text>
      <xsl:for-each select="$domain/data/field[@name!=$pkdomain/pk/field/@name]">
        <xsl:text>
            database.AddParameter(</xsl:text>
        <xsl:apply-templates select="." mode="parameter-args">
          <xsl:with-param name="pos" select="position()"/>
        </xsl:apply-templates>
        <xsl:text>
            );
</xsl:text>
      </xsl:for-each>
      <xsl:text>
            return command;
        }

        /// &lt;summary /&gt;
        private static DbCommand _CreateUpdateCommand(Database database, Salamanca.DataAccess.Data.ParameterBuilder parameterBuilder, </xsl:text>
      <xsl:value-of select="$domainName"/>
      <xsl:text>.DataTransfer data)
        {
            DbCommand command=database.GetSqlStringCommand(
                string.Format(
                    CultureInfo.InvariantCulture,
                    Resources.Sql.</xsl:text>
      <xsl:value-of select="$domainName"/>
      <xsl:text>Update,</xsl:text>
      <xsl:for-each select="$pkdomain/data/field[$domain/@extends and @name=$pkdomain/pk/field/@name] | $domain/data/field">
        <xsl:sort select="@name=$pkdomain/pk/field/@name"/>
        <xsl:text>
                    parameterBuilder.GetMarker("</xsl:text>
        <xsl:value-of select="@column"/>
        <xsl:text>", </xsl:text>
        <xsl:value-of select="position()"/>
        <xsl:text>)</xsl:text>
        <xsl:if test="position()!=last()">
          <xsl:text>,</xsl:text>
        </xsl:if>
      </xsl:for-each>
      <xsl:text>
                )
            );
</xsl:text>
      <xsl:for-each select="$pkdomain/data/field[$domain/@extends and @name=$pkdomain/pk/field/@name] | $domain/data/field">
        <xsl:sort select="@name=$pkdomain/pk/field/@name"/>
        <xsl:text>
            database.AddParameter(</xsl:text>
        <xsl:apply-templates select="." mode="parameter-args">
          <xsl:with-param name="pos" select="position()"/>
        </xsl:apply-templates>
        <xsl:text>
            );
</xsl:text>
      </xsl:for-each>
      <xsl:text>
            return command;
        }

        /// &lt;summary&gt;Gets the parameter builder instance.&lt;/summary&gt;
        /// &lt;value&gt;The parameter builder instance.&lt;/value&gt;
        protected Salamanca.DataAccess.Data.ParameterBuilder ParameterBuilder
        {
            get
            {
                return _ParameterBuilder;
            }
        }

        private Salamanca.DataAccess.Data.ParameterBuilder _ParameterBuilder;

    }

}
</xsl:text>
    </xsl:variable>
    <xsl:value-of select="nyext:generateFile($src, nyext:combinePath($outdir, concat(nyext:getModelFileName($name), '.cs')))"/>
  </xsl:template>
  
  <xsl:template match="/">
    <xsl:call-template name="generate-user-file"/>
    <xsl:call-template name="generate-model-file"/>
  </xsl:template>
</xsl:stylesheet>
